import { exec } from 'child_process';
import { promisify } from 'util';
import { PlatformHelper } from './platformHelper';

const execAsync = promisify(exec);

export interface Environment {
    type: 'podman' | 'docker' | 'none';
    version?: string;
    path?: string;
    platform?: {
        type: string;
        isWSL: boolean;
        isRootless: boolean;
    };
}

export class EnvironmentDetector {
    private platformHelper: PlatformHelper;

    constructor() {
        this.platformHelper = PlatformHelper.getInstance();
    }

    /**
     * 检测系统环境中的容器运行时
     * 优先检测 Podman，然后是 Docker，最后回退到内置代理
     */
    async detect(): Promise<Environment> {
        try {
            // 检查平台特定信息
            await this.platformHelper.checkUserPrivileges();

            // 获取平台信息
            const platformInfo = {
                type: this.platformHelper.getPlatformType(),
                isWSL: this.platformHelper.isWSLEnvironment(),
                isRootless: this.platformHelper.isRootlessEnvironment()
            };
            
            // 根据平台选择合适的检测顺序
            // 在 Windows 上优先检测 Docker，因为 Podman 在 Windows 上使用较少
            if (this.platformHelper.isWindows()) {
                // 首先检测 Docker
                const dockerEnv = await this.checkDocker();
                if (dockerEnv) {
                    dockerEnv.platform = platformInfo;
                    return dockerEnv;
                }
                
                // 然后检测 Podman
                const podmanEnv = await this.checkPodman();
                if (podmanEnv) {
                    podmanEnv.platform = platformInfo;
                    return podmanEnv;
                }
            } else {
                // 在 Linux/macOS 上优先检测 Podman (更安全，rootless by default)
                // 首先检测 Podman
                const podmanEnv = await this.checkPodman();
                if (podmanEnv) {
                    podmanEnv.platform = platformInfo;
                    return podmanEnv;
                }
                
                // 然后检测 Docker
                const dockerEnv = await this.checkDocker();
                if (dockerEnv) {
                    dockerEnv.platform = platformInfo;
                    return dockerEnv;
                }
            }
            
            // 如果都没有，则返回 none，但仍包含平台信息
            return { 
                type: 'none',
                platform: platformInfo
            };
        } catch (error) {
            console.error('Error detecting environment:', error);
            return { type: 'none' };
        }
    }
    
    /**
     * 检测 Podman 是否可用
     */
    private async checkPodman(): Promise<Environment | null> {
        try {
            // 获取平台特定的 Podman 命令选项
            const options = this.platformHelper.getContainerOptions('podman');
            const optionsStr = Object.values(options).join(' ');
            
            // 检测 Podman 版本
            const { stdout } = await execAsync(`podman ${optionsStr} --version`);
            const version = stdout.trim();
            
            // 检测 podman 是否真的可用（尝试获取一些信息）
            await execAsync(`podman ${optionsStr} info`);
            
            return {
                type: 'podman',
                version,
                path: await this.getCommandPath('podman')
            };
        } catch (error) {
            console.log('Podman not available:', error);
            return null;
        }
    }
    
    /**
     * 检测 Docker 是否可用
     */
    private async checkDocker(): Promise<Environment | null> {
        try {
            // 获取平台特定的 Docker 命令选项
            const options = this.platformHelper.getContainerOptions('docker');
            const optionsStr = Object.values(options).join(' ');
            
            // 检测 Docker 版本
            const { stdout } = await execAsync(`docker ${optionsStr} --version`);
            const version = stdout.trim();
            
            // 检测 docker 是否真的可用（尝试获取一些信息）
            const { stdout: infoOutput } = await execAsync(`docker ${optionsStr} info`);
            
            // 检查是否为 rootless 模式 (更安全)
            const isRootless = infoOutput.includes('Rootless');
            
            // 如果不是 rootless 模式，我们也接受，但后续可能会显示警告
            return {
                type: 'docker',
                version,
                path: await this.getCommandPath('docker')
            };
        } catch (error) {
            console.log('Docker not available:', error);
            return null;
        }
    }
    
    /**
     * 获取命令的完整路径
     */
    private async getCommandPath(command: string): Promise<string | undefined> {
        try {
            // 根据平台使用不同的命令来获取可执行文件路径
            let whichCmd = 'which';
            
            if (this.platformHelper.isWindows()) {
                whichCmd = 'where';
            }
            
            const { stdout } = await execAsync(`${whichCmd} ${command}`);
            return stdout.trim().split('\n')[0]; // 取第一行，因为 where 在 Windows 上可能返回多个路径
        } catch {
            return undefined;
        }
    }
} 